package org.convallaria.system.biz.util;

import org.convallaria.framework.common.constants.sys.RoleConstants;
import org.convallaria.system.biz.entity.SysRole;

/**
 * 系统角色工具类
 * 
 * 功能特性：
 * - 提供角色相关的业务逻辑判断方法
 * - 提供角色状态、数据范围等描述信息
 * - 提供角色数据验证方法
 * - 提供角色信息格式化方法
 * 
 * 设计原则：
 * - 纯静态方法，无状态
 * - 业务逻辑与实体类分离
 * - 便于单元测试
 * - 提高代码可维护性
 * 
 * @author convallaria
 * @since 1.0.0
 */
public class SysRoleUtils {

    // ==================== 状态判断方法 ====================

    /**
     * 判断角色是否正常状态
     * 
     * @param role 角色对象
     * @return true=正常，false=停用
     */
    public static boolean isNormal(SysRole role) {
        if (role == null || role.getStatus() == null) {
            return false;
        }
        return RoleConstants.ROLE_STATUS_NORMAL.equals(role.getStatus());
    }

    /**
     * 判断角色是否停用状态
     * 
     * @param role 角色对象
     * @return true=停用，false=正常
     */
    public static boolean isDisabled(SysRole role) {
        if (role == null || role.getStatus() == null) {
            return false;
        }
        return RoleConstants.ROLE_STATUS_DISABLED.equals(role.getStatus());
    }

    /**
     * 判断角色状态是否有效
     * 
     * @param status 状态值
     * @return true=有效，false=无效
     */
    public static boolean isValidStatus(String status) {
        return RoleConstants.isValidRoleStatus(status);
    }

    // ==================== 数据范围判断方法 ====================

    /**
     * 判断是否为全部数据权限
     * 
     * @param role 角色对象
     * @return true=全部数据权限，false=其他
     */
    public static boolean isDataScopeAll(SysRole role) {
        if (role == null || role.getDataScope() == null) {
            return false;
        }
        return RoleConstants.isDataScopeAll(role.getDataScope());
    }

    /**
     * 判断是否为自定数据权限
     * 
     * @param role 角色对象
     * @return true=自定数据权限，false=其他
     */
    public static boolean isDataScopeCustom(SysRole role) {
        if (role == null || role.getDataScope() == null) {
            return false;
        }
        return RoleConstants.isDataScopeCustom(role.getDataScope());
    }

    /**
     * 判断是否为本部门数据权限
     * 
     * @param role 角色对象
     * @return true=本部门数据权限，false=其他
     */
    public static boolean isDataScopeDept(SysRole role) {
        if (role == null || role.getDataScope() == null) {
            return false;
        }
        return RoleConstants.isDataScopeDept(role.getDataScope());
    }

    /**
     * 判断是否为本部门及以下数据权限
     * 
     * @param role 角色对象
     * @return true=本部门及以下数据权限，false=其他
     */
    public static boolean isDataScopeDeptAndChild(SysRole role) {
        if (role == null || role.getDataScope() == null) {
            return false;
        }
        return RoleConstants.isDataScopeDeptAndChild(role.getDataScope());
    }

    /**
     * 判断数据范围是否有效
     * 
     * @param dataScope 数据范围值
     * @return true=有效，false=无效
     */
    public static boolean isValidDataScope(String dataScope) {
        return RoleConstants.isValidDataScope(dataScope);
    }

    // ==================== 特殊角色判断方法 ====================

    /**
     * 判断是否为超级管理员角色
     * 
     * @param role 角色对象
     * @return true=超级管理员，false=其他
     */
    public static boolean isSuperAdminRole(SysRole role) {
        if (role == null || role.getRoleKey() == null) {
            return false;
        }
        return RoleConstants.isSuperAdminRole(role.getRoleKey());
    }

    /**
     * 判断是否为普通用户角色
     * 
     * @param role 角色对象
     * @return true=普通用户，false=其他
     */
    public static boolean isUserRole(SysRole role) {
        if (role == null || role.getRoleKey() == null) {
            return false;
        }
        return RoleConstants.isUserRole(role.getRoleKey());
    }

    /**
     * 判断是否为访客角色
     * 
     * @param role 角色对象
     * @return true=访客，false=其他
     */
    public static boolean isGuestRole(SysRole role) {
        if (role == null || role.getRoleKey() == null) {
            return false;
        }
        return RoleConstants.isGuestRole(role.getRoleKey());
    }

    // ==================== 数据验证方法 ====================

    /**
     * 验证角色信息是否完整
     * 
     * @param role 角色对象
     * @return true=完整，false=不完整
     */
    public static boolean isValidRole(SysRole role) {
        if (role == null) {
            return false;
        }
        
        // 必填字段验证
        if (!RoleConstants.isValidRoleName(role.getRoleName())) {
            return false;
        }
        if (!RoleConstants.isValidRoleKey(role.getRoleKey())) {
            return false;
        }
        if (role.getTenantId() == null) {
            return false;
        }
        
        // 状态验证
        if (!isValidStatus(role.getStatus())) {
            return false;
        }
        
        // 数据范围验证
        if (role.getDataScope() != null && !isValidDataScope(role.getDataScope())) {
            return false;
        }
        
        // 显示顺序验证
        if (role.getRoleSort() != null && !RoleConstants.isValidRoleSort(role.getRoleSort())) {
            return false;
        }
        
        return true;
    }

    /**
     * 验证角色名称格式
     * 
     * @param roleName 角色名称
     * @return true=有效，false=无效
     */
    public static boolean isValidRoleName(String roleName) {
        return RoleConstants.isValidRoleName(roleName);
    }

    /**
     * 验证角色权限字符串格式
     * 
     * @param roleKey 角色权限字符串
     * @return true=有效，false=无效
     */
    public static boolean isValidRoleKey(String roleKey) {
        return RoleConstants.isValidRoleKey(roleKey);
    }

    /**
     * 验证角色排序格式
     * 
     * @param roleSort 角色排序
     * @return true=有效，false=无效
     */
    public static boolean isValidRoleSort(Integer roleSort) {
        return RoleConstants.isValidRoleSort(roleSort);
    }

    // ==================== 格式化方法 ====================

    /**
     * 格式化角色显示名称
     * 
     * @param role 角色对象
     * @return 格式化后的显示名称
     */
    public static String formatDisplayName(SysRole role) {
        if (role == null) {
            return "未知角色";
        }
        
        String displayName = role.getRoleName();
        if (displayName == null || displayName.trim().isEmpty()) {
            displayName = role.getRoleKey();
        }
        
        return displayName != null ? displayName : "未知角色";
    }

    /**
     * 格式化角色完整信息
     * 
     * @param role 角色对象
     * @return 格式化后的完整信息
     */
    public static String formatRoleInfo(SysRole role) {
        if (role == null) {
            return "角色信息为空";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("角色ID: ").append(role.getRoleId()).append(", ");
        sb.append("角色名称: ").append(role.getRoleName()).append(", ");
        sb.append("角色权限: ").append(role.getRoleKey()).append(", ");
        sb.append("状态: ").append(getStatusDesc(role.getStatus())).append(", ");
        sb.append("数据范围: ").append(getDataScopeDesc(role.getDataScope()));
        
        return sb.toString();
    }

    // ==================== 描述信息方法 ====================

    /**
     * 获取角色状态描述
     * 
     * @param status 状态值
     * @return 状态描述
     */
    public static String getStatusDesc(String status) {
        return RoleConstants.getRoleStatusDesc(status);
    }

    /**
     * 获取数据范围描述
     * 
     * @param dataScope 数据范围值
     * @return 数据范围描述
     */
    public static String getDataScopeDesc(String dataScope) {
        return RoleConstants.getDataScopeDesc(dataScope);
    }

    // ==================== 业务逻辑方法 ====================

    /**
     * 判断角色是否可以删除
     * 
     * @param role 角色对象
     * @return true=可以删除，false=不能删除
     */
    public static boolean canDelete(SysRole role) {
        if (role == null) {
            return false;
        }
        
        // 超级管理员角色不能删除
        if (isSuperAdminRole(role)) {
            return false;
        }
        
        // 停用的角色可以删除
        return isDisabled(role);
    }

    /**
     * 判断角色是否可以编辑
     * 
     * @param role 角色对象
     * @return true=可以编辑，false=不能编辑
     */
    public static boolean canEdit(SysRole role) {
        if (role == null) {
            return false;
        }
        
        // 正常状态的角色可以编辑
        return isNormal(role);
    }

    /**
     * 判断角色是否可以选择
     * 
     * @param role 角色对象
     * @return true=可以选择，false=不能选择
     */
    public static boolean canSelect(SysRole role) {
        if (role == null) {
            return false;
        }
        
        // 正常状态的角色可以选择
        return isNormal(role);
    }

    /**
     * 判断角色是否为空
     * 
     * @param role 角色对象
     * @return true=为空，false=不为空
     */
    public static boolean isEmpty(SysRole role) {
        if (role == null) {
            return true;
        }
        
        return (role.getRoleName() == null || role.getRoleName().trim().isEmpty()) &&
               (role.getRoleKey() == null || role.getRoleKey().trim().isEmpty());
    }

    /**
     * 判断角色是否有效（非空且状态正常）
     * 
     * @param role 角色对象
     * @return true=有效，false=无效
     */
    public static boolean isValid(SysRole role) {
        return !isEmpty(role) && isNormal(role);
    }

    /**
     * 比较角色显示顺序
     * 
     * @param role1 角色对象1
     * @param role2 角色对象2
     * @return 比较结果：负数表示role1在前，正数表示role2在前，0表示相等
     */
    public static int compareRoleSort(SysRole role1, SysRole role2) {
        if (role1 == null && role2 == null) {
            return 0;
        }
        if (role1 == null) {
            return 1;
        }
        if (role2 == null) {
            return -1;
        }
        
        Integer sort1 = role1.getRoleSort();
        Integer sort2 = role2.getRoleSort();
        
        if (sort1 == null && sort2 == null) {
            return 0;
        }
        if (sort1 == null) {
            return 1;
        }
        if (sort2 == null) {
            return -1;
        }
        
        return sort1.compareTo(sort2);
    }
}